package com.css.fxfzfxqh.modules.buildings.definitiveEvaluation.util;

import com.css.fxfzfxqh.modules.buildings.calculationTasks.entity.YSXMainTable;
import com.css.fxfzfxqh.modules.buildings.definitiveEvaluation.casualtiesDE.entity.BuildingVulnerability;
import com.css.fxfzfxqh.modules.util.repository.YSXRepository;
import com.css.fxfzfxqh.util.PlatformObjectUtils;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.crypto.spec.IvParameterSpec;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author: zhangSongRui
 * @CreateTime: 2023/10/11
 * @Description: 易损性数据
 */
@Service
public class YSXUtil {

    @Resource
    private YSXRepository ysxRepository;

    /**
     * 房屋格网用
     * @param typeName 格网结构类型字典值
     * @param damageDegree 破坏状态
     * @param intensity 烈度
     * @param pName 省名称
     * @param cName 市名称
     * @param name  县名称
     * @param taskId 任务id
     * @return Map<设防烈度,易损性值>
     */
    public Map<String, Double> getYSX(String typeName,String damageDegree,String intensity, String pName, String cName, String name,String taskId) {
        //将结构类型字典值转换成ysx结构值
        String structureTypeName = getStructureType(typeName);
        if (null==structureTypeName){
            return null;
        }
        String[] split = structureTypeName.split("-");
        String type1=split[0];
        String type2=null;
        if (split.length>1){
            type2=split[1];
        }
        return ysxEncapsulation(type1,type2,damageDegree,intensity,pName,cName,name,taskId);
    }

    /**
     * 房屋单体用
     * @param type1 结构类型1
     * @param type2 结构类型2
     * @param damageDegree 破坏状态
     * @param intensity 地震烈度
     * @param pName 省名称
     * @param cName 市名称
     * @param name 县名称
     * @param taskId 任务id
     * @return Map<设防烈度,易损性值>
     */
    public Map<String, Double> getYSX(String type1,String type2,String damageDegree,String intensity, String pName,
                                      String cName, String name,String taskId) {
        return ysxEncapsulation(type1,type2,damageDegree,intensity,pName,cName,name,taskId);
    }

    //根据省市县获取本省市县下的所有易损性
    public Map<String, Map<String, Map<String, BuildingVulnerability>>> getYSX(String taskId, String pName, String cName,String name) {
        List<YSXMainTable> ysxList = ysxRepository.getYSX2(taskId, pName, cName, name);
        if (ysxList == null || ysxList.size() < 1) {
            throw new RuntimeException("评估失败,请维护" + pName + "-" + cName + "-" + name + "的易损性数据");
        }
        Map<String, Map<String, Map<String, BuildingVulnerability>>> mapMapMap = new HashMap<>();
        Map<String, Map<String, BuildingVulnerability>> mapMap=null;
        Map<String, BuildingVulnerability> map=null;
        BuildingVulnerability entity=null;
        for (YSXMainTable ysxMainTable: ysxList){
            String key1=null;
            if (PlatformObjectUtils.isEmpty(ysxMainTable.getStructureType1())){
                key1=ysxMainTable.getStructureType2();
            }else if(PlatformObjectUtils.isEmpty(ysxMainTable.getStructureType2())){
                key1=ysxMainTable.getStructureType1();
            }else if (ysxMainTable.getStructureType1().equals(ysxMainTable.getStructureType2())){
                key1=ysxMainTable.getStructureType1();
            }else {
                key1=ysxMainTable.getStructureType1() +"-"+ ysxMainTable.getStructureType2();
            }
            if (mapMapMap.containsKey(key1)){
                mapMap=mapMapMap.get(key1);
            }else {
                mapMap=new HashMap<>();
            }
            if (mapMap.containsKey(ysxMainTable.getFortify())){
                map=mapMap.get(ysxMainTable.getFortify());
            }else {
                map=new HashMap<>();
            }
            //设置地震烈度
            String key3=ysxMainTable.getIntensity().replace("度", "");
            if (map.containsKey(key3)){
                entity=map.get(key3);
            }else {
                entity=new BuildingVulnerability();
                //设防烈度
                entity.setSfIntensity(ysxMainTable.getFortify());
                entity.setIntensity(key3);
            }
            switch (ysxMainTable.getDamage()){
                case "基本完好": entity.setBasic(new BigDecimal(ysxMainTable.getRate().replace("%", "")));break;
                case "轻微破坏": entity.setSlight(new BigDecimal(ysxMainTable.getRate().replace("%", "")));break;
                case "中等破坏": entity.setMid(new BigDecimal(ysxMainTable.getRate().replace("%", "")));break;
                case "严重破坏": entity.setSerious(new BigDecimal(ysxMainTable.getRate().replace("%", "")));break;
                case "倒塌": entity.setDestroy(new BigDecimal(ysxMainTable.getRate().replace("%", "")));break;
            }
            //<地震烈度,易损性数据>
            map.put(key3,entity);
            //<设防烈度,<地震烈度,易损性数据>>
            mapMap.put(ysxMainTable.getFortify(),map);
            //<结构类型,<设防烈度,<地震烈度,易损性数据>>>
            mapMapMap.put(key1,mapMap);
        }
        return mapMapMap;
    }

    /**
     *
     * @param taskId 任务Id
     * @param pName  省
     * @param cName 市
     * @param name 县
     * @return key 结构类型_毁坏程度_烈度
     */
    public Map<String,List<YSXMainTable>> ysxEncapsulationNew(String taskId,String pName,String cName,String name){
        List<YSXMainTable> ysx2 = ysxRepository.getYSX2(taskId, pName, cName, name);
        Map<String, List<YSXMainTable>> collect = ysx2.stream().collect(Collectors.groupingBy(entity -> entity.getStructureType1() +"-"+ entity.getStructureType2() + entity.getDamage() + entity.getIntensity()));
        return collect;
    }
    public Map<String,List<YSXMainTable>> ysxEncapsulationNew2(String taskId,String pName,String cName,String name){
        List<YSXMainTable> ysx2 = ysxRepository.getYSX2(taskId, pName, cName, name);
        Map<String, List<YSXMainTable>> map = new HashMap<>();
        if(PlatformObjectUtils.isNotEmpty(ysx2)){
            for (YSXMainTable entity : ysx2) {
                if(StringUtils.isBlank(entity.getStructureType2())){
                    entity.setStructureType2(entity.getStructureType1());
                }
                if(map.containsKey(entity.getStructureType1() +"-"+ entity.getStructureType2() + entity.getDamage() + entity.getIntensity())){
                    List<YSXMainTable> ysxMainTables = map.get(entity.getStructureType1() + "-" + entity.getStructureType2() + entity.getDamage() + entity.getIntensity());
                    ysxMainTables.add(entity);
                    map.put(entity.getStructureType1() + "-" + entity.getStructureType2() + entity.getDamage() + entity.getIntensity(),ysxMainTables);
                }else{
                    List<YSXMainTable> ysxMainTables = new ArrayList<>();
                    ysxMainTables.add(entity);
                    map.put(entity.getStructureType1() + "-" + entity.getStructureType2() + entity.getDamage() + entity.getIntensity(),ysxMainTables);
                }
            }
        }
        //Map<String, List<YSXMainTable>> collect = ysx2.stream().collect(Collectors.groupingBy(entity -> entity.getStructureType1() +"-"+ entity.getStructureType2() + entity.getDamage() + entity.getIntensity()));
        return map;
    }

    public Map<String, List<YSXMainTable>> ysxEncapsulationNew1(String taskId,String pName,String cName,String name){
        //格式类型 <结构类型-设防烈度,List<实体对象>>
        Map<String, List<YSXMainTable>> collect = new HashMap<>();
        //根据省市县查询易损性数据
        List<YSXMainTable> ysx2 = ysxRepository.getYSX2(taskId, pName, cName, name);
        //组建数据
        if(PlatformObjectUtils.isNotEmpty(ysx2) && ysx2.size()>0){
            //按照结构类型和烈度进行分组
            collect = ysx2.stream().collect(Collectors.groupingBy(entity -> entity.getStructureType1() + "-" + (PlatformObjectUtils.isNotEmpty(entity.getStructureType2())?entity.getStructureType2():entity.getStructureType1()) +"_"+ entity.getFortify()));
        }
        return collect;
    }

    //根据条件获取并处理易损性数据
    public Map<String, Double> ysxEncapsulation(String type1,String type2,String damageDegree,String intensity,
                                                String pName, String cName, String name,String taskId){
        //烈度字典值转度
        String ld = ldConversion(intensity);
        List<YSXMainTable> list = ysxRepository.getYSX1(type1,type2,damageDegree,ld,pName, cName, name,taskId);
        //写入数据
        Map<String, Double> map=new HashMap<>();
        for (YSXMainTable ysxEntity : list) {
            switch (ysxEntity.getFortify()) {
                case "未设防":
                    map.put("未设防", Double.valueOf(ysxEntity.getRate().replace("%", "")));
                    break;
                case "6度":
                    map.put("6度", Double.valueOf(ysxEntity.getRate().replace("%", "")));
                    break;
                case "7度":
                    map.put("7度", Double.valueOf(ysxEntity.getRate().replace("%", "")));
                    break;
                case "8度":
                    map.put("8度", Double.valueOf(ysxEntity.getRate().replace("%", "")));
                    break;
                case "9度":
                    map.put("9度", Double.valueOf(ysxEntity.getRate().replace("%", "")));
                    break;
                case "自设防":
                    map.put("自设防", Double.valueOf(ysxEntity.getRate().replace("%", "")));
                    break;
                case "其他":
                    map.put("其他", Double.valueOf(ysxEntity.getRate().replace("%", "")));
                    break;
            }
        }
        return map;
    }

    public static String getStructureType(String type){
        if (type.equals("czghjggw")|type.equals("ncgjggw")|type.equals("ncghjggw")){
            return "钢筋混凝土结构-框架结构";
        }
        if (type.equals("czmjggw")|type.equals("ncmzjggw")){
            return "木结构";
        }
        if (type.equals("czqtjglxgw")|type.equals("nchzjggw")|type.equals("ncqtjglxgw")){
            return "其他";
        }
        if (type.equals("czqtjggw")|type.equals("ncdbkjkzqqtjggw")|type.equals("ncqtjggw")){
            return "砌体结构-砖混结构";
        }
        if (type.equals("nctmsmjggw")){
            return "土木结构";
        }
        if (type.equals("czgjggw")){
            return "钢结构";
        }
        return null;
    }

    //ld1转6度
    public String ldConversion(String intensity) {
        if(PlatformObjectUtils.isNotEmpty(intensity)){
            switch (intensity) {
                case "ld0":
                    return "5度";
                case "ld1":
                    return "6度";
                case "ld2":
                    return "7度";
                case "ld3":
                    return "8度";
                case "ld4":
                    return "9度";
                case "ld5":
                    return "10度";
                case "ld6":
                    return "11度";
                case "ld7":
                    return "12度";
            }
        }
        return null;
    }

    //pgcd1转基本完好
    public String phcdConversion(String damageDegree) {
        if(PlatformObjectUtils.isNotEmpty(damageDegree)){
            switch (damageDegree) {
                case "pgcd1":
                    return "基本完好";
                case "pgcd2":
                    return "轻微破坏";
                case "pgcd3":
                    return "中等破坏";
                case "pgcd4":
                    return "严重破坏";
                case "pgcd5":
                    return "倒塌";
            }
        }
        return null;
    }


    //根据省市县获取本省市县下的所有易损性  旧版
//    private HashMap<String, Map<String, Map<String, YSXEntity>>> getYSX(String pName, String cName, String name) {
//        List<YSXEntity> list = ysxRepository.getYSX(pName, cName, name);
//        //结构类型
//        HashMap<String, Map<String, Map<String, YSXEntity>>> structureType = new HashMap<>();
//        //创建数据结构
//        for (int j = 0; j < 13; j++) {
//            Map<String, Map<String, YSXEntity>> fortify = new HashMap<>();
//            for (int i = 0; i < 7; i++) {
//                Map<String, YSXEntity> intensity = new HashMap<>();
//                if (i == 0) {
//                    fortify.put("未设防", intensity);
//                }
//                if (i == 1) {
//                    fortify.put("6度", intensity);
//                }
//                if (i == 2) {
//                    fortify.put("7度", intensity);
//                }
//                if (i == 3) {
//                    fortify.put("8度", intensity);
//                }
//                if (i == 4) {
//                    fortify.put("9度", intensity);
//                }
//                if (i == 5) {
//                    fortify.put("自设防", intensity);
//                }
//                if (i == 6) {
//                    fortify.put("其他", intensity);
//                }
//            }
//            if (j == 0) {
//                structureType.put("czghjggw", fortify);
//            }
//            if (j == 1) {
//                structureType.put("czmjggw", fortify);
//            }
//            if (j == 2) {
//                structureType.put("czqtjglxgw", fortify);
//            }
//            if (j == 3) {
//                structureType.put("czqtjggw", fortify);
//            }
//            if (j == 4) {
//                structureType.put("ncdbkjkzqqtjggw", fortify);
//            }
//            if (j == 5) {
//                structureType.put("ncghjggw", fortify);
//            }
//            if (j == 6) {
//                structureType.put("ncgjggw", fortify);
//            }
//            if (j == 7) {
//                structureType.put("nchzjggw", fortify);
//            }
//            if (j == 8) {
//                structureType.put("ncmzjggw", fortify);
//            }
//            if (j == 9) {
//                structureType.put("ncqtjglxgw", fortify);
//            }
//            if (j == 10) {
//                structureType.put("ncqtjggw", fortify);
//            }
//            if (j == 11) {
//                structureType.put("nctmsmjggw", fortify);
//            }
//            if (j == 12) {
//                structureType.put("czgjggw", fortify);
//            }
//        }
//        //写入数据
//        for (YSXEntity ysxEntity : list) {
//            //根据结构类型
//            switch (ysxEntity.getStructure_type()) {
//                //城镇钢混结构房屋网格
//                case "钢筋混凝土结构-框架结构":
//                    //根据结构类型分
//                    Map<String, YSXEntity> czghjggw = structureType.get("czghjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, czghjggw);
//                    Map<String, YSXEntity> ncgjggw = structureType.get("ncgjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, ncgjggw);
//                    Map<String, YSXEntity> ncghjggw = structureType.get("ncghjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, ncghjggw);
//                    break;
////                case "钢筋混凝土结构-框架-剪力墙结构":
////                    Map<String, YSX> czghjggw2 = structureType.get("czghjggw2").get(ysx.getFortify());
////                    getDamageDegreeMap(ysx, czghjggw2);
////                    break;
////                case "剪力墙结构":
////                    //根据结构类型分
////                    Map<String, YSX> czghjggw3 = structureType.get("czghjggw3").get(ysx.getFortify());
////                    getDamageDegreeMap(ysx, czghjggw3);
////                    break;
//                //城镇木结构房屋格网
//                case "木结构":
//                    Map<String, YSXEntity> czmjggw = structureType.get("czmjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, czmjggw);
//                    Map<String, YSXEntity> ncmzjggw = structureType.get("ncmzjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, ncmzjggw);
//                    break;
//                //城镇其他结构房屋格网
//                case "其他":
//                    Map<String, YSXEntity> czqtjglxgw = structureType.get("czqtjglxgw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, czqtjglxgw);
//                    Map<String, YSXEntity> nchzjggw = structureType.get("nchzjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, nchzjggw);
//                    Map<String, YSXEntity> ncqtjglxgw = structureType.get("ncqtjglxgw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, ncqtjglxgw);
//                    break;
//                //城镇砌体结构房屋格网
//                case "砌体结构-砖混结构":
//                    Map<String, YSXEntity> czqtjggw = structureType.get("czqtjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, czqtjggw);
//                    Map<String, YSXEntity> ncdbkjkzqqtjggw = structureType.get("ncdbkjkzqqtjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, ncdbkjkzqqtjggw);
//                    Map<String, YSXEntity> ncqtjggw = structureType.get("ncqtjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, ncqtjggw);
//                    break;
//                //农村土木（石木）结构房屋格网
//                case "土木结构":
//                    Map<String, YSXEntity> nctmsmjggw = structureType.get("nctmsmjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, nctmsmjggw);
//                    break;
//                //城镇钢结构房屋格网
//                case "钢结构":
//                    Map<String, YSXEntity> czgjggw = structureType.get("czgjggw").get(ysxEntity.getFortify());
//                    getDamageDegreeMap(ysxEntity, czgjggw);
//                    break;
//                default:
//                    break;
//            }
//        }
//        return structureType;
//    }
}
